home *** CD-ROM | disk | FTP | other *** search
/ Languguage OS 2 / Languguage OS II Version 10-94 (Knowledge Media)(1994).ISO / gnu / uucp-104.lha / uucp-1.04 / uucp.c < prev    next >
C/C++ Source or Header  |  1993-02-13  |  29KB  |  1,182 lines
  1. /* uucp.c
  2.    Prepare to copy a file to or from a remote system.
  3.  
  4.    Copyright (C) 1991, 1992 Ian Lance Taylor
  5.  
  6.    This file is part of the Taylor UUCP package.
  7.  
  8.    This program is free software; you can redistribute it and/or
  9.    modify it under the terms of the GNU General Public License as
  10.    published by the Free Software Foundation; either version 2 of the
  11.    License, or (at your option) any later version.
  12.  
  13.    This program is distributed in the hope that it will be useful, but
  14.    WITHOUT ANY WARRANTY; without even the implied warranty of
  15.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16.    General Public License for more details.
  17.  
  18.    You should have received a copy of the GNU General Public License
  19.    along with this program; if not, write to the Free Software
  20.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  21.  
  22.    The author of the program may be contacted at ian@airs.com or
  23.    c/o Infinity Development Systems, P.O. Box 520, Waltham, MA 02254.
  24.    */
  25.  
  26. #include "uucp.h"
  27.  
  28. #if USE_RCS_ID
  29. const char uucp_rcsid[] = "$Id: uucp.c,v 1.43 1993/01/01 16:31:03 ian Rel $";
  30. #endif
  31.  
  32. #include <ctype.h>
  33. #include <errno.h>
  34.  
  35. #include "getopt.h"
  36.  
  37. #include "uudefs.h"
  38. #include "uuconf.h"
  39. #include "system.h"
  40.  
  41. /* Local functions.  */
  42.  
  43. static void ucusage P((void));
  44. static void ucdirfile P((const char *zdir, const char *zfile,
  45.              pointer pinfo));
  46. static void uccopy P((const char *zfile, const char *zdest));
  47. static void ucadd_cmd P((const struct uuconf_system *qsys,
  48.              const struct scmd *qcmd, const char *zlog));
  49. static void ucspool_cmds P((boolean fjobid));
  50. static const char *zcone_system P((boolean *pfany));
  51. static void ucrecord_file P((const char *zfile));
  52. static void ucabort P((void));
  53.  
  54. /* The program name.  */
  55. char abProgram[] = "uucp";
  56.  
  57. /* Long getopt options.  */
  58. static const struct option asClongopts[] = { { NULL, 0, NULL, 0 } };
  59.  
  60. /* Local variables.  There are a bunch of these, mostly set by the
  61.    options and the last (the destination) argument.  These have file
  62.    scope so that they may be easily passed into uccopy; they could for
  63.    the most part also be wrapped up in a structure and passed in.  */
  64.  
  65. /* The uuconf global pointer.  */
  66. static pointer pCuuconf;
  67.  
  68. /* TRUE if source files should be copied to the spool directory.  */
  69. static boolean fCcopy = TRUE;
  70.  
  71. /* Grade to use.  */
  72. static char bCgrade = BDEFAULT_UUCP_GRADE;
  73.  
  74. /* Whether to send mail to the requesting user when the copy is
  75.    complete.  */
  76. static boolean fCmail = FALSE;
  77.  
  78. /* User to notify on remote system.  */
  79. static const char *zCnotify = "";
  80.  
  81. /* TRUE if remote files should be prefixed with the current working
  82.    directory.  */
  83. static boolean fCexpand = TRUE;
  84.  
  85. /* TRUE if necessary directories should be created on the destination
  86.    system.  */
  87. static boolean fCmkdirs = TRUE;
  88.  
  89. /* Local name.  */
  90. static const char *zClocalname;
  91.  
  92. /* User name.  */
  93. static const char *zCuser = NULL;
  94.  
  95. /* TRUE if this is a remote request.  */
  96. static boolean fCremote = FALSE;
  97.  
  98. /* TRUE if the destination is this system.  */
  99. static boolean fClocaldest;
  100.  
  101. /* Destination system.  */
  102. static struct uuconf_system sCdestsys;
  103.  
  104. /* Systems to forward to, if not NULL.  */
  105. static char *zCforward;
  106.  
  107. /* Options to use when sending a file.  */
  108. static char abCsend_options[20];
  109.  
  110. /* Options to use when receiving a file.  */
  111. static char abCrec_options[20];
  112.  
  113. /* TRUE if the current file being copied from is in the cwd.  */
  114. static boolean fCneeds_cwd;
  115.  
  116. /* The main program.  */
  117.  
  118. int
  119. main (argc, argv)
  120.      int argc;
  121.      char **argv;
  122. {
  123.   /* -I: configuration file name.  */
  124.   const char *zconfig = NULL;
  125.   /* -j: output job id.  */
  126.   boolean fjobid = FALSE;
  127.   /* -r: don't start uucico when finished.  */
  128.   boolean fuucico = TRUE;
  129.   /* -R: copy directories recursively.  */
  130.   boolean frecursive = FALSE;
  131.   /* -s: report status to named file.  */
  132.   const char *zstatus_file = NULL;
  133.   /* -t: emulate uuto.  */
  134.   boolean fuuto = FALSE;
  135.   int iopt;
  136.   pointer puuconf;
  137.   int iuuconf;
  138.   int i;
  139.   boolean fgetcwd;
  140.   char *zexclam;
  141.   char *zdestfile;
  142.   const char *zdestsys;
  143.   char *zoptions;
  144.   boolean fexit;
  145.  
  146.   while ((iopt = getopt_long (argc, argv, "cCdfg:I:jmn:prRs:tu:Wx:",
  147.                   asClongopts, (int *) NULL)) != EOF)
  148.     {
  149.       switch (iopt)
  150.     {
  151.     case 'c':
  152.       /* Do not copy local files to spool directory.  */
  153.       fCcopy = FALSE;
  154.       break;
  155.  
  156.     case 'p':
  157.     case 'C':
  158.       /* Copy local files to spool directory.  */
  159.       fCcopy = TRUE;
  160.       break;
  161.  
  162.     case 'd':
  163.       /* Create directories if necessary.  */
  164.       fCmkdirs = TRUE;
  165.       break;
  166.  
  167.     case 'f':
  168.       /* Do not create directories if they don't exist.  */
  169.       fCmkdirs = FALSE;
  170.       break;
  171.  
  172.     case 'g':
  173.       /* Set job grade.  */
  174.       bCgrade = optarg[0];
  175.       break;
  176.  
  177.     case 'I':
  178.       /* Name configuration file.  */
  179.       if (fsysdep_other_config (optarg))
  180.         zconfig = optarg;
  181.       break;
  182.  
  183.     case 'j':
  184.       /* Output job id.  */
  185.       fjobid = TRUE;
  186.       break;
  187.  
  188.     case 'm':
  189.       /* Mail to requesting user.  */
  190.       fCmail = TRUE;
  191.       break;
  192.  
  193.     case 'n':
  194.       /* Notify remote user.  */
  195.       zCnotify = optarg;
  196.       break;
  197.  
  198.     case 'r':
  199.       /* Don't start uucico when finished.  */
  200.       fuucico = FALSE;
  201.       break;
  202.  
  203.     case 'R':
  204.       /* Copy directories recursively.  */
  205.       frecursive = TRUE;
  206.       break;
  207.  
  208.     case 's':
  209.       /* Report status to named file.  */
  210.       zstatus_file = optarg;
  211.       break;
  212.  
  213.     case 't':
  214.       /* Emulate uuto.  */
  215.       fuuto = TRUE;
  216.       break;
  217.  
  218.     case 'u':
  219.       /* Set user name.  */
  220.       zCuser = optarg;
  221.       break;
  222.  
  223.     case 'W':
  224.       /* Expand only local file names.  */
  225.       fCexpand = FALSE;
  226.       break;
  227.  
  228.     case 'x':
  229. #if DEBUG > 1
  230.       /* Set debugging level.  */
  231.       iDebug |= idebug_parse (optarg);
  232. #endif
  233.       break;
  234.  
  235.     case 0:
  236.       /* Long option found and flag set.  */
  237.       break;
  238.  
  239.     default:
  240.       ucusage ();
  241.       break;
  242.     }
  243.     }
  244.  
  245.   if (! UUCONF_GRADE_LEGAL (bCgrade))
  246.     {
  247.       ulog (LOG_ERROR, "Ignoring illegal grade");
  248.       bCgrade = BDEFAULT_UUCP_GRADE;
  249.     }
  250.  
  251.   /* The user name must contain a '!', which is treated as a remote
  252.      name, to avoid spoofing of other users (there is no advantage to
  253.      spoofing remote users, except to send them random bits of mail,
  254.      which you can do anyhow).  */
  255.   if (zCuser != NULL)
  256.     {
  257.       if (strchr (zCuser, '!') != NULL)
  258.     fCremote = TRUE;
  259.       else
  260.     {
  261.       ulog (LOG_ERROR, "Ignoring local user name");
  262.       zCuser = NULL;
  263.     }
  264.     }
  265.  
  266.   if (argc - optind < 2)
  267.     ucusage ();
  268.  
  269.   iuuconf = uuconf_init (&puuconf, (const char *) NULL, zconfig);
  270.   if (iuuconf != UUCONF_SUCCESS)
  271.     ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
  272.   pCuuconf = puuconf;
  273.  
  274. #if DEBUG > 1
  275.   {
  276.     const char *zdebug;
  277.  
  278.     iuuconf = uuconf_debuglevel (puuconf, &zdebug);
  279.     if (iuuconf != UUCONF_SUCCESS)
  280.       ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
  281.     if (zdebug != NULL)
  282.       iDebug |= idebug_parse (zdebug);
  283.   }
  284. #endif
  285.  
  286.   /* See if we are going to need to know the current directory.  We
  287.      just check each argument to see whether it's an absolute
  288.      pathname.  We actually aren't going to need the cwd if fCexpand
  289.      is FALSE and the file is remote, but so what.  */
  290.   fgetcwd = FALSE;
  291.   for (i = optind; i < argc; i++)
  292.     {
  293.       zexclam = strrchr (argv[i], '!');
  294.       if (zexclam == NULL)
  295.     zexclam = argv[i];
  296.       else
  297.     ++zexclam;
  298.       if (fsysdep_needs_cwd (zexclam))
  299.     {
  300.       fgetcwd = TRUE;
  301.       break;
  302.     }
  303.     }
  304.  
  305. #ifdef SIGINT
  306.   usysdep_signal (SIGINT);
  307. #endif
  308. #ifdef SIGHUP
  309.   usysdep_signal (SIGHUP);
  310. #endif
  311. #ifdef SIGQUIT
  312.   usysdep_signal (SIGQUIT);
  313. #endif
  314. #ifdef SIGTERM
  315.   usysdep_signal (SIGTERM);
  316. #endif
  317. #ifdef SIGPIPE
  318.   usysdep_signal (SIGPIPE);
  319. #endif
  320.  
  321.   usysdep_initialize (puuconf, INIT_SUID | (fgetcwd ? INIT_GETCWD : 0));
  322.  
  323.   ulog_fatal_fn (ucabort);
  324.  
  325.   if (zCuser == NULL)
  326.     zCuser = zsysdep_login_name ();
  327.  
  328.   iuuconf = uuconf_localname (puuconf, &zClocalname);
  329.   if (iuuconf == UUCONF_NOT_FOUND)
  330.     {
  331.       zClocalname = zsysdep_localname ();
  332.       if (zClocalname == NULL)
  333.     exit (EXIT_FAILURE);
  334.     }
  335.   else if (iuuconf != UUCONF_SUCCESS)
  336.     ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
  337.  
  338.   /* If we are emulating uuto, translate the destination argument, and
  339.      notify the destination user.  This had better not turn into
  340.      something that requires the current directory, or we may have
  341.      passed INIT_GETCWD incorrectly.  */
  342.   if (fuuto)
  343.     {
  344.       if (*zCnotify == '\0')
  345.     {
  346.       zexclam = strrchr (argv[argc - 1], '!');
  347.       if (zexclam == NULL)
  348.         ucusage ();
  349.       zCnotify = zexclam + 1;
  350.     }
  351.       argv[argc - 1] = zsysdep_uuto (argv[argc - 1], zClocalname);
  352.       if (argv[argc - 1] == NULL)
  353.     ucusage ();
  354.     }
  355.  
  356.   /* Set up the file transfer options.  */
  357.   zoptions = abCsend_options;
  358.   if (fCcopy)
  359.     *zoptions++ = 'C';
  360.   else
  361.     *zoptions++ = 'c';
  362.   if (fCmkdirs)
  363.     *zoptions++ = 'd';
  364.   else
  365.     *zoptions++ = 'f';
  366.   if (fCmail)
  367.     *zoptions++ = 'm';
  368.   if (*zCnotify != '\0')
  369.     *zoptions++ = 'n';
  370.   *zoptions = '\0';
  371.  
  372.   zoptions = abCrec_options;
  373.   if (fCmkdirs)
  374.     *zoptions++ = 'd';
  375.   else
  376.     *zoptions++ = 'f';
  377.   if (fCmail)
  378.     *zoptions++ = 'm';
  379.   *zoptions = '\0';
  380.  
  381.   zexclam = strchr (argv[argc - 1], '!');
  382.   if (zexclam == NULL)
  383.     {
  384.       zdestsys = zClocalname;
  385.       zdestfile = argv[argc - 1];
  386.       fClocaldest = TRUE;
  387.     }
  388.   else
  389.     {
  390.       size_t clen;
  391.       char *zcopy;
  392.  
  393.       clen = zexclam - argv[argc - 1];
  394.       zcopy = zbufalc (clen + 1);
  395.       memcpy (zcopy, argv[argc - 1], clen);
  396.       zcopy[clen] = '\0';
  397.       zdestsys = zcopy;
  398.  
  399.       zdestfile = zexclam + 1;
  400.  
  401.       fClocaldest = FALSE;
  402.     }
  403.  
  404.   iuuconf = uuconf_system_info (puuconf, zdestsys, &sCdestsys);
  405.   if (iuuconf != UUCONF_SUCCESS)
  406.     {
  407.       if (iuuconf != UUCONF_NOT_FOUND)
  408.     ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
  409.       if (fClocaldest)
  410.     {
  411.       iuuconf = uuconf_system_local (puuconf, &sCdestsys);
  412.       if (iuuconf != UUCONF_SUCCESS)
  413.         ulog_uuconf (LOG_FATAL, puuconf, iuuconf);
  414.       sCdestsys.uuconf_zname = (char *) zClocalname;
  415.     }
  416.       else
  417.     {
  418.       if (! funknown_system (puuconf, zdestsys, &sCdestsys))
  419.         ulog (LOG_FATAL, "%s: System not found", zdestsys);
  420.     }
  421.     }
  422.  
  423.   /* Here zdestfile is the destination file name following the
  424.      destination system name (if any); it may contain other systems to
  425.      forward the files through.  Isolate the file from the list of
  426.      systems.  */
  427.   zexclam = strrchr (zdestfile, '!');
  428.   if (zexclam == NULL)
  429.     zCforward = NULL;
  430.   else
  431.     {
  432.       size_t clen;
  433.  
  434. #if DEBUG > 0
  435.       if (fClocaldest)
  436.     ulog (LOG_FATAL, "Can't happen");
  437. #endif
  438.       clen = zexclam - zdestfile;
  439.       zCforward = zbufalc (clen + 1);
  440.       memcpy (zCforward, zdestfile, clen);
  441.       zCforward[clen] = '\0';
  442.       zdestfile = zexclam + 1;
  443.     }
  444.  
  445.   /* Turn the destination into an absolute path, unless it is on a
  446.      remote system and -W was used.  */
  447.   if (fClocaldest)
  448.     zdestfile = zsysdep_local_file_cwd (zdestfile, sCdestsys.uuconf_zpubdir);
  449.   else if (fCexpand)
  450.     zdestfile = zsysdep_add_cwd (zdestfile);
  451.   if (zdestfile == NULL)
  452.     {
  453.       ulog_close ();
  454.       usysdep_exit (FALSE);
  455.     }
  456.  
  457.   /* Process each source argument.  */
  458.   for (i = optind; i < argc - 1 && ! FGOT_SIGNAL (); i++)
  459.     {
  460.       boolean flocal;
  461.       char *zfrom;
  462.  
  463.       fCneeds_cwd = FALSE;
  464.  
  465.       if (strchr (argv[i], '!') != NULL)
  466.     {
  467.       flocal = FALSE;
  468.       zfrom = zbufcpy (argv[i]);
  469.     }
  470.       else
  471.     {
  472.       /* This is a local file.  Make sure we get it out of the
  473.          original directory.  We don't support local wildcards,
  474.          leaving that to the shell.  */
  475.       flocal = TRUE;
  476.       if (fsysdep_needs_cwd (argv[i]))
  477.         fCneeds_cwd = TRUE;
  478.       zfrom = zsysdep_local_file_cwd (argv[i],
  479.                       sCdestsys.uuconf_zpubdir);
  480.       if (zfrom == NULL)
  481.         ucabort ();
  482.     }
  483.  
  484.       if (! flocal || ! fsysdep_directory (zfrom))
  485.     uccopy (zfrom, zdestfile);
  486.       else
  487.     {
  488.       char *zbase, *zindir;
  489.  
  490.       if (! frecursive)
  491.         ulog (LOG_FATAL, "%s: directory without -R", zfrom);
  492.  
  493.       zbase = zsysdep_base_name (zfrom);
  494.       if (zbase == NULL)
  495.         ucabort ();
  496.       zindir = zsysdep_in_dir (zdestfile, zbase);
  497.       ubuffree (zbase);
  498.       if (zindir == NULL)
  499.         ucabort ();
  500.       usysdep_walk_tree (zfrom, ucdirfile, zindir);
  501.       ubuffree (zindir);
  502.     }
  503.  
  504.       ubuffree (zfrom);
  505.     }
  506.  
  507.   /* See if we got an interrupt, presumably from the user.  */
  508.   if (FGOT_SIGNAL ())
  509.     ucabort ();
  510.  
  511.   /* Now push out the actual commands, making log entries for them.  */
  512.   ulog_to_file (puuconf, TRUE);
  513.   ulog_user (zCuser);
  514.  
  515.   ucspool_cmds (fjobid);
  516.  
  517.   ulog_close ();
  518.  
  519.   if (! fuucico)
  520.     fexit = TRUE;
  521.   else
  522.     {
  523.       const char *zsys;
  524.       boolean fany;
  525.  
  526.       zsys = zcone_system (&fany);
  527.       if (zsys != NULL)
  528.     fexit = fsysdep_run ("uucico", "-s", zsys);
  529.       else if (fany)
  530.     fexit = fsysdep_run ("uucico", "-r1", (const char *) NULL);
  531.       else
  532.     fexit = TRUE;
  533.     }
  534.  
  535.   usysdep_exit (fexit);
  536.  
  537.   /* Avoid error about not returning.  */
  538.   return 0;
  539. }
  540.  
  541. static void
  542. ucusage ()
  543. {
  544.   fprintf (stderr,
  545.        "Taylor UUCP version %s, copyright (C) 1991, 1992 Ian Lance Taylor\n",
  546.        VERSION);
  547.   fprintf (stderr,
  548.        "Usage: uucp [options] file1 [file2 ...] dest\n");
  549.   fprintf (stderr,
  550.        " -c: Do not copy local files to spool directory\n");
  551.   fprintf (stderr,
  552.        " -C, -p: Copy local files to spool directory (default)\n");
  553.   fprintf (stderr,
  554.        " -d: Create necessary directories (default)\n");
  555.   fprintf (stderr,
  556.        " -f: Do not create directories (fail if they do not exist)\n");
  557.   fprintf (stderr,
  558.        " -g grade: Set job grade (must be alphabetic)\n");
  559.   fprintf (stderr,
  560.        " -m: Report status of copy by mail\n");
  561.   fprintf (stderr,
  562.        " -n user: Report status of copy by mail to remote user\n");
  563.   fprintf (stderr,
  564.        " -R: Copy directories recursively\n");
  565.   fprintf (stderr,
  566.        " -r: Do not start uucico daemon\n");
  567.   fprintf (stderr,
  568.        " -s file: Report completion status to file\n");
  569.   fprintf (stderr,
  570.        " -j: Report job id\n");
  571.   fprintf (stderr,
  572.        " -W: Do not add current directory to remote filenames\n");
  573.   fprintf (stderr,
  574.        " -t: Emulate uuto\n");
  575.   fprintf (stderr,
  576.        " -u name: Set user name\n");
  577.   fprintf (stderr,
  578.        " -x debug: Set debugging level\n");
  579. #if HAVE_TAYLOR_CONFIG
  580.   fprintf (stderr,
  581.        " -I file: Set configuration file to use\n");
  582. #endif /* HAVE_TAYLOR_CONFIG */
  583.   exit (EXIT_FAILURE);
  584. }
  585.  
  586. /* This is called for each file in a directory heirarchy.  */
  587.  
  588. static void
  589. ucdirfile (zfull, zrelative, pinfo)
  590.      const char *zfull;
  591.      const char *zrelative;
  592.      pointer pinfo;
  593. {
  594.   const char *zdestfile = (const char *) pinfo;
  595.   char *zto;
  596.  
  597.   zto = zsysdep_in_dir (zdestfile, zrelative);
  598.   if (zto == NULL)
  599.     ucabort ();
  600.  
  601.   uccopy (zfull, zto);
  602.  
  603.   ubuffree (zto);
  604. }
  605.  
  606. /* Handle the copying of one regular file.  The zdest argument is the
  607.    destination file; if we are recursively copying a directory, it
  608.    will be extended by any subdirectory names.  Note that zdest is an
  609.    absolute path.  */
  610.  
  611. static void
  612. uccopy (zfile, zdest)
  613.      const char *zfile;
  614.      const char *zdest;
  615. {
  616.   struct scmd s;
  617.   char *zexclam;
  618.   char *zto;
  619.  
  620.   zexclam = strchr (zfile, '!');
  621.  
  622.   if (zexclam == NULL)
  623.     {
  624.       openfile_t efrom;
  625.  
  626.       /* Copy from a local file.  Make sure the user has access to
  627.      this file, since we are running setuid.  */
  628.       if (! fsysdep_access (zfile))
  629.     ucabort ();
  630.  
  631.       /* If this copy is being requested by a remote system, we may
  632.      transfer the file if it needs the current working directory
  633.      (meaning, I hope, that it is in the execution directory) or
  634.      it is on the permitted transfer list.  Note that unlike most
  635.      of the other checks, this one is not double-checked by
  636.      uucico.  */
  637.       if (fCremote
  638.       && ! fCneeds_cwd
  639.       && ! fin_directory_list (zfile, sCdestsys.uuconf_pzremote_send,
  640.                    sCdestsys.uuconf_zpubdir, TRUE,
  641.                    TRUE, (const char *) NULL))
  642.     ulog (LOG_FATAL, "Not permitted to send %s", zfile);
  643.  
  644.       if (fClocaldest)
  645.     {
  646.       boolean fok;
  647.  
  648.       /* Copy one local file to another.  */
  649.  
  650.       /* Check that we have permission to receive into the desired
  651.          directory.  */
  652.       if (fCremote)
  653.         fok = fin_directory_list (zdest,
  654.                       sCdestsys.uuconf_pzremote_receive,
  655.                       sCdestsys.uuconf_zpubdir, TRUE,
  656.                       FALSE, (const char *) NULL);
  657.       else
  658.         fok = fin_directory_list (zdest,
  659.                       sCdestsys.uuconf_pzlocal_receive,
  660.                       sCdestsys.uuconf_zpubdir, TRUE,
  661.                       FALSE, zCuser);
  662.       if (! fok)
  663.         ulog (LOG_FATAL, "Not permitted to receive to %s", zdest);
  664.  
  665.       zto = zsysdep_add_base (zdest, zfile);
  666.       if (zto == NULL)
  667.         ucabort ();
  668.  
  669.       efrom = esysdep_user_fopen (zfile, TRUE, TRUE);
  670.       if (! ffileisopen (efrom))
  671.         ucabort ();
  672.       if (! fcopy_open_file (efrom, zto, FALSE, fCmkdirs))
  673.         ucabort ();
  674.       (void) ffileclose (efrom);
  675.       ubuffree (zto);
  676.     }
  677.       else
  678.     {
  679.       const char *zloc;
  680.       char abtname[CFILE_NAME_LEN];
  681.       unsigned int imode;
  682.       char *ztemp;
  683.  
  684.       /* Copy a local file to a remote file.  We may have to
  685.          copy the local file to the spool directory.  */
  686.       imode = ixsysdep_file_mode (zfile);
  687.       if (imode == 0)
  688.         ucabort ();
  689.  
  690.       zloc = sCdestsys.uuconf_zlocalname;
  691.       if (zloc == NULL)
  692.         zloc = zClocalname;
  693.  
  694.       ztemp = zsysdep_data_file_name (&sCdestsys, zloc, bCgrade,
  695.                       FALSE, abtname, (char *) NULL,
  696.                       (char *) NULL);
  697.       if (ztemp == NULL)
  698.         ucabort ();
  699.  
  700.       if (! fCcopy)
  701.         {
  702.           /* If we are copying the file, we don't actually use the
  703.          temporary file; we still want to get a name for the
  704.          other system to use as a key for file restart.  */
  705.           ubuffree (ztemp);
  706.  
  707.           /* Make sure the daemon will be permitted to send
  708.          this file.  */
  709.           if (! fsysdep_daemon_access (zfile))
  710.         ucabort ();
  711.           if (! fin_directory_list (zfile, sCdestsys.uuconf_pzlocal_send,
  712.                     sCdestsys.uuconf_zpubdir, TRUE, TRUE,
  713.                     (fCremote
  714.                      ? (const char *) NULL
  715.                      : zCuser)))
  716.         ulog (LOG_FATAL, "Not permitted to send %s", zfile);
  717.         }
  718.       else
  719.         {
  720.           efrom = esysdep_user_fopen (zfile, TRUE, TRUE);
  721.           if (! ffileisopen (efrom))
  722.         ucabort ();
  723.           ucrecord_file (ztemp);
  724.           if (! fcopy_open_file (efrom, ztemp, FALSE, TRUE))
  725.         ucabort ();
  726.           (void) ffileclose (efrom);
  727.         }
  728.  
  729.       if (zCforward == NULL)
  730.         {
  731.           /* We're not forwarding.  Just send the file.  */
  732.           s.bcmd = 'S';
  733.           s.pseq = NULL;
  734.           s.zfrom = zbufcpy (zfile);
  735.           s.zto = zbufcpy (zdest);
  736.           s.zuser = zCuser;
  737.           s.zoptions = abCsend_options;
  738.           s.ztemp = zbufcpy (abtname);
  739.           s.imode = imode;
  740.           s.znotify = zCnotify;
  741.           s.cbytes = -1;
  742.           s.zcmd = NULL;
  743.           s.ipos = 0;
  744.  
  745.           ucadd_cmd (&sCdestsys, &s, (const char *) NULL);
  746.         }
  747.       else
  748.         {
  749.           char *zbase;
  750.           char *zxqt;
  751.           char abxtname[CFILE_NAME_LEN];
  752.           char abdname[CFILE_NAME_LEN];
  753.           char abxname[CFILE_NAME_LEN];
  754.           FILE *e;
  755.           char *zlog;
  756.  
  757.           /* We want to forward this file through sCdestsys to
  758.          some other system(s).  We set up a remote execution
  759.          of uucp on sCdestsys to forward the file along.  */
  760.           zbase = zsysdep_base_name (zfile);
  761.           if (zbase == NULL)
  762.         ucabort ();
  763.  
  764.           zxqt = zsysdep_data_file_name (&sCdestsys, zloc, bCgrade,
  765.                          TRUE, abxtname, abdname,
  766.                          abxname);
  767.           if (zxqt == NULL)
  768.         ucabort ();
  769.           e = esysdep_fopen (zxqt, FALSE, FALSE, TRUE);
  770.           if (e == NULL)
  771.         ucabort ();
  772.           ucrecord_file (zxqt);
  773.  
  774.           fprintf (e, "U %s %s\n", zCuser, zloc);
  775.           fprintf (e, "F %s %s\n", abdname, zbase);
  776.           fprintf (e, "C uucp -C");
  777.           if (fCmkdirs)
  778.         fprintf (e, " -d");
  779.           else
  780.         fprintf (e, " -f");
  781.           fprintf (e, " -g %c", bCgrade);
  782.           if (fCmail)
  783.         fprintf (e, " -m");
  784.           if (*zCnotify != '\0')
  785.         fprintf (e, " -n %s", zCnotify);
  786.           if (! fCexpand)
  787.         fprintf (e, " -W");
  788.           fprintf (e, " %s %s!%s\n", zbase, zCforward, zdest);
  789.  
  790.           ubuffree (zbase);
  791.  
  792.           if (fclose (e) != 0)
  793.         ulog (LOG_FATAL, "fclose: %s", strerror (errno));
  794.  
  795.           /* Send the execution file.  */
  796.           s.bcmd = 'S';
  797.           s.pseq = NULL;
  798.           s.zfrom = zbufcpy (abxtname);
  799.           s.zto = zbufcpy (abxname);
  800.           s.zuser = zCuser;
  801.            s.zoptions = "C";
  802.           s.ztemp = s.zfrom;
  803.           s.imode = 0666;
  804.           s.znotify = NULL;
  805.           s.cbytes = -1;
  806.           s.zcmd = NULL;
  807.           s.ipos = 0;
  808.  
  809.           zlog = zbufalc (sizeof "Queuing uucp  !" + strlen (zfile)
  810.                   + strlen (zCforward) + strlen (zdest));
  811.           sprintf (zlog, "Queuing uucp %s %s!%s", zfile, zCforward,
  812.                zdest);
  813.  
  814.           ucadd_cmd (&sCdestsys, &s, zlog);
  815.  
  816.           /* Send the data file.  */
  817.           s.bcmd = 'S';
  818.           s.pseq = NULL;
  819.           s.zfrom = zbufcpy (zfile);
  820.           s.zto = zbufcpy (abdname);
  821.           s.zuser = zCuser;
  822.            s.zoptions = fCcopy ? "C" : "c";
  823.           s.ztemp = zbufcpy (abtname);
  824.           s.imode = 0666;
  825.           s.znotify = NULL;
  826.           s.cbytes = -1;
  827.           s.zcmd = NULL;
  828.           s.ipos = 0;
  829.  
  830.           ucadd_cmd (&sCdestsys, &s, "");
  831.         }
  832.     }
  833.     }
  834.   else
  835.     {
  836.       char *zfrom;
  837.       char *zforward;
  838.       size_t clen;
  839.       char *zcopy;
  840.       struct uuconf_system *qfromsys;
  841.       int iuuconf;
  842.       const char *zloc;
  843.  
  844.       /* Copy from a remote file.  Get the file name after any systems
  845.      we may need to forward the file from.  */
  846.       zfrom = strrchr (zfile, '!');
  847.       if (zfrom == zexclam)
  848.     zforward = NULL;
  849.       else
  850.     {
  851.       clen = zfrom - zexclam - 1;
  852.       zforward = zbufalc (clen + 1);
  853.       memcpy (zforward, zexclam + 1, clen);
  854.     }
  855.  
  856.       ++zfrom;
  857.       if (fCexpand)
  858.     {
  859.       /* Add the current directory to the filename if it's not
  860.          already there.  */
  861.       zfrom = zsysdep_add_cwd (zfrom);
  862.       if (zfrom == NULL)
  863.         ucabort ();
  864.     }
  865.  
  866.       /* Read the system information.  */
  867.       clen = zexclam - zfile;
  868.       zcopy = zbufalc (clen + 1);
  869.       memcpy (zcopy, zfile, clen);
  870.       zcopy[clen] = '\0';
  871.  
  872.       qfromsys = ((struct uuconf_system *)
  873.           xmalloc (sizeof (struct uuconf_system)));
  874.  
  875.       iuuconf = uuconf_system_info (pCuuconf, zcopy, qfromsys);
  876.       if (iuuconf == UUCONF_NOT_FOUND)
  877.     {
  878.       if (! funknown_system (pCuuconf, zcopy, qfromsys))
  879.         ulog (LOG_FATAL, "%s: System not found", zcopy);
  880.     }
  881.       else if (iuuconf != UUCONF_SUCCESS)
  882.     ulog_uuconf (LOG_FATAL, pCuuconf, iuuconf);
  883.       ubuffree (zcopy);
  884.  
  885.       zloc = qfromsys->uuconf_zlocalname;
  886.       if (zloc == NULL)
  887.     zloc = zClocalname;
  888.  
  889.       if (zforward == NULL && fClocaldest)
  890.     {
  891.       boolean fok;
  892.  
  893.       /* The file is to come directly from qfromsys to the local
  894.          system.  */
  895.  
  896.       /* Check that we have permission to receive into the desired
  897.          directory.  If we don't have permission, uucico will
  898.          fail.  */
  899.       if (fCremote)
  900.         fok = fin_directory_list (zdest,
  901.                       qfromsys->uuconf_pzremote_receive,
  902.                       qfromsys->uuconf_zpubdir, TRUE,
  903.                       FALSE, (const char *) NULL);
  904.       else
  905.         fok = fin_directory_list (zdest,
  906.                       qfromsys->uuconf_pzlocal_receive,
  907.                       qfromsys->uuconf_zpubdir, TRUE,
  908.                       FALSE, zCuser);
  909.       if (! fok)
  910.         ulog (LOG_FATAL, "Not permitted to receive to %s", zdest);
  911.  
  912.       /* If the remote filespec is wildcarded, we must generate an
  913.          'X' request.  We currently check for Unix shell
  914.          wildcards.  Note that it should do no harm to mistake a
  915.          non-wildcard for a wildcard.  */
  916.       if (zfrom[strcspn (zfrom, "*?[")] != '\0')
  917.         {
  918.           s.bcmd = 'X';
  919.           zto = zbufalc (strlen (zloc) + strlen (zdest) + sizeof "!");
  920.           sprintf (zto, "%s!%s", zloc, zdest);
  921.         }
  922.       else
  923.         {
  924.           s.bcmd = 'R';
  925.           zto = zbufcpy (zdest);
  926.         }
  927.  
  928.       s.pseq = NULL;
  929.       s.zfrom = zfrom;
  930.       s.zto = zto;
  931.       s.zuser = zCuser;
  932.       s.zoptions = abCrec_options;
  933.       s.ztemp = "";
  934.       s.imode = 0;
  935.       s.znotify = "";
  936.       s.cbytes = -1;
  937.       s.zcmd = NULL;
  938.       s.ipos = 0;
  939.  
  940.       ucadd_cmd (qfromsys, &s, (const char *) NULL);
  941.     }
  942.       else
  943.     {
  944.       char *zxqt;
  945.       char abtname[CFILE_NAME_LEN];
  946.       char abxname[CFILE_NAME_LEN];
  947.       FILE *e;
  948.       char *zcmd;
  949.       char *zlog;
  950.  
  951.       /* The file either comes from some other system through
  952.          qfromsys or is intended for some other system.  Send an
  953.          execution request to qfromsys to handle everything.  */
  954.       zxqt = zsysdep_data_file_name (qfromsys, zloc, bCgrade, TRUE,
  955.                      abtname, (char *) NULL,
  956.                      abxname);
  957.       if (zxqt == NULL)
  958.         ucabort ();
  959.       e = esysdep_fopen (zxqt, FALSE, FALSE, TRUE);
  960.       if (e == NULL)
  961.         ucabort ();
  962.       ucrecord_file (zxqt);
  963.  
  964.       fprintf (e, "U %s %s\n", zCuser, zloc);
  965.       fprintf (e, "C uucp -C");
  966.       if (fCmkdirs)
  967.         fprintf (e, " -d");
  968.       else
  969.         fprintf (e, " -f");
  970.       fprintf (e, " -g %c", bCgrade);
  971.       if (fCmail)
  972.         fprintf (e, " -m");
  973.       if (*zCnotify != '\0')
  974.         fprintf (e, " -n %s", zCnotify);
  975.       if (! fCexpand)
  976.         fprintf (e, " -W");
  977.  
  978.       clen = (strlen (zfrom) + strlen (zloc)
  979.           + strlen (sCdestsys.uuconf_zname) + strlen (zdest));
  980.       if (zforward != NULL)
  981.         clen += strlen (zforward);
  982.       if (zCforward != NULL)
  983.         clen += strlen (zCforward);
  984.       zcmd = zbufalc (sizeof "! !!!" + clen);
  985.       *zcmd = '\0';
  986.       if (zforward != NULL)
  987.         sprintf (zcmd + strlen (zcmd), "%s!", zforward);
  988.       sprintf (zcmd + strlen (zcmd), "%s %s!", zfrom, zloc);
  989.       if (! fClocaldest)
  990.         sprintf (zcmd + strlen (zcmd), "%s!", sCdestsys.uuconf_zname);
  991.       if (zCforward != NULL)
  992.         sprintf (zcmd + strlen (zcmd), "%s!", zCforward);
  993.       sprintf (zcmd + strlen (zcmd), "%s", zdest);
  994.  
  995.       fprintf (e, " %s\n", zcmd);
  996.  
  997.       if (fclose (e) != 0)
  998.         ulog (LOG_FATAL, "fclose: %s", strerror (errno));
  999.  
  1000.       /* Send the execution file.  */
  1001.       s.bcmd = 'S';
  1002.       s.pseq = NULL;
  1003.       s.zfrom = zbufcpy (abtname);
  1004.       s.zto = zbufcpy (abxname);
  1005.       s.zuser = zCuser;
  1006.       s.zoptions = "C";
  1007.       s.ztemp = s.zfrom;
  1008.       s.imode = 0666;
  1009.       s.znotify = NULL;
  1010.       s.cbytes = -1;
  1011.       s.zcmd = NULL;
  1012.       s.ipos = 0;
  1013.  
  1014.       zlog = zbufalc (sizeof "Queueing uucp " + strlen (zcmd));
  1015.       sprintf (zlog, "Queueing uucp %s", zcmd);
  1016.  
  1017.       ucadd_cmd (qfromsys, &s, zlog);
  1018.  
  1019.       ubuffree (zcmd);
  1020.       ubuffree (zforward);
  1021.     }
  1022.     }
  1023. }
  1024.  
  1025. /* We keep a list of jobs for each system.  */
  1026.  
  1027. struct sjob
  1028. {
  1029.   struct sjob *qnext;
  1030.   const struct uuconf_system *qsys;
  1031.   int ccmds;
  1032.   struct scmd *pascmds;
  1033.   const char **pazlogs;
  1034. };
  1035.  
  1036. static struct sjob *qCjobs;
  1037.  
  1038. static void
  1039. ucadd_cmd (qsys, qcmd, zlog)
  1040.      const struct uuconf_system *qsys;
  1041.      const struct scmd *qcmd;
  1042.      const char *zlog;
  1043. {
  1044.   struct sjob *qjob;
  1045.  
  1046.   if (! qsys->uuconf_fcall_transfer
  1047.       && ! qsys->uuconf_fcalled_transfer)
  1048.     ulog (LOG_FATAL, "Not permitted to transfer files to or from %s",
  1049.       qsys->uuconf_zname);
  1050.  
  1051.   for (qjob = qCjobs; qjob != NULL; qjob = qjob->qnext)
  1052.     if (strcmp (qjob->qsys->uuconf_zname, qsys->uuconf_zname) == 0)
  1053.       break;
  1054.  
  1055.   if (qjob == NULL)
  1056.     {
  1057.       qjob = (struct sjob *) xmalloc (sizeof (struct sjob));
  1058.       qjob->qnext = qCjobs;
  1059.       qjob->qsys = qsys;
  1060.       qjob->ccmds = 0;
  1061.       qjob->pascmds = NULL;
  1062.       qjob->pazlogs = NULL;
  1063.       qCjobs = qjob;
  1064.     }
  1065.  
  1066.   qjob->pascmds = ((struct scmd *)
  1067.            xrealloc ((pointer) qjob->pascmds,
  1068.                  (qjob->ccmds + 1) * sizeof (struct scmd)));
  1069.   qjob->pascmds[qjob->ccmds] = *qcmd;
  1070.   qjob->pazlogs = ((const char **)
  1071.            xrealloc ((pointer) qjob->pazlogs,
  1072.                  (qjob->ccmds + 1) * sizeof (const char *)));
  1073.   qjob->pazlogs[qjob->ccmds] = zlog;
  1074.   ++qjob->ccmds;
  1075. }
  1076.  
  1077. static void
  1078. ucspool_cmds (fjobid)
  1079.      boolean fjobid;
  1080. {
  1081.   struct sjob *qjob;
  1082.   char *zjobid;
  1083.  
  1084.   for (qjob = qCjobs; qjob != NULL; qjob = qjob->qnext)
  1085.     {
  1086.       ulog_system (qjob->qsys->uuconf_zname);
  1087.       zjobid = zsysdep_spool_commands (qjob->qsys, bCgrade, qjob->ccmds,
  1088.                        qjob->pascmds);
  1089.       if (zjobid != NULL)
  1090.     {
  1091.       int i;
  1092.       struct scmd *qcmd;
  1093.       const char **pz;
  1094.  
  1095.       for (i = 0, qcmd = qjob->pascmds, pz = qjob->pazlogs;
  1096.            i < qjob->ccmds;
  1097.            i++, qcmd++, pz++)
  1098.         {
  1099.           if (*pz != NULL)
  1100.         {
  1101.           if (**pz != '\0')
  1102.             ulog (LOG_NORMAL, "%s", *pz);
  1103.         }
  1104.           else if (qcmd->bcmd == 'S')
  1105.         ulog (LOG_NORMAL, "Queuing send of %s to %s",
  1106.               qcmd->zfrom, qcmd->zto);
  1107.           else if (qcmd->bcmd == 'R')
  1108.         ulog (LOG_NORMAL, "Queuing request of %s to %s",
  1109.               qcmd->zfrom, qcmd->zto);
  1110.           else
  1111.         {
  1112.           const char *zto;
  1113.  
  1114.           zto = strrchr (qcmd->zto, '!');
  1115.           if (zto != NULL)
  1116.             ++zto;
  1117.           else
  1118.             zto = qcmd->zto;
  1119.           ulog (LOG_NORMAL, "Queuing request of %s to %s",
  1120.             qcmd->zfrom, zto);
  1121.         }
  1122.         }
  1123.  
  1124.       if (fjobid)
  1125.         printf ("%s\n", zjobid);
  1126.  
  1127.       ubuffree (zjobid);
  1128.     }
  1129.     }
  1130. }
  1131.  
  1132. /* Return the system name for which we have created commands, or NULL
  1133.    if we've created commands for more than one system.  Set *pfany to
  1134.    FALSE if we didn't create work for any system.  */
  1135.  
  1136. static const char *
  1137. zcone_system (pfany)
  1138.      boolean *pfany;
  1139. {
  1140.   if (qCjobs == NULL)
  1141.     {
  1142.       *pfany = FALSE;
  1143.       return NULL;
  1144.     }
  1145.  
  1146.   *pfany = TRUE;
  1147.  
  1148.   if (qCjobs->qnext == NULL)
  1149.     return qCjobs->qsys->uuconf_zname;
  1150.   else
  1151.     return NULL;
  1152. }
  1153.  
  1154. /* Keep track of all files we have created so that we can delete them
  1155.    if we get a signal.  The argument will be on the heap.  */
  1156.  
  1157. static int cCfiles;
  1158. static const char **pCaz;
  1159.  
  1160. static void
  1161. ucrecord_file (zfile)
  1162.      const char *zfile;
  1163. {
  1164.   pCaz = (const char **) xrealloc ((pointer) pCaz,
  1165.                    (cCfiles + 1) * sizeof (const char *));
  1166.   pCaz[cCfiles] = zfile;
  1167.   ++cCfiles;
  1168. }
  1169.  
  1170. /* Delete all the files we have recorded and exit.  */
  1171.  
  1172. static void
  1173. ucabort ()
  1174. {
  1175.   int i;
  1176.  
  1177.   for (i = 0; i < cCfiles; i++)
  1178.     (void) remove (pCaz[i]);
  1179.   ulog_close ();
  1180.   usysdep_exit (FALSE);
  1181. }
  1182.